Llega un momento en el que escribir más código deja de hacerte más productivo. No necesitas otro framework. Necesitas menos problemas.
Después de construir suficientes proyectos personales, herramientas internas, APIs, dashboards, scripts de automatización y pipelines de datos, hay un patrón que se repite: los desarrolladores que sacan las cosas adelante más rápido no son los que escriben mejor Python, son los que se apoyan en mejores librerías. Y no siempre las que salen en todos los «Top 20» del sector, sino las que eliminan de golpe categorías enteras de trabajo.
Aquí tienes catorce que merece la pena tener siempre a mano, sobre todo si trabajas solo o en equipos muy pequeños y no puedes permitirte perder horas en fontanería.
Antes de nada: gestiona el entorno con uv
Antes de hablar de librerías conviene resolver algo más básico: cómo instalas y gestionas todo lo demás. Durante años pip, venv, poetry y pyenv convivían a base de parches. uv, de Astral (los creadores de Ruff), ha sustituido a los cuatro en la mayoría de proyectos nuevos: gestiona versiones de Python, dependencias y entornos virtuales desde un único binario escrito en Rust, con una velocidad que hace que pip parezca de otra década. En marzo de 2026, OpenAI incorporó a Astral a su equipo de Codex, así que el mantenimiento de la herramienta tiene detrás bastante más músculo del habitual en un proyecto de código abierto.
uv init proyecto cd proyecto uv add requests uv run python main.py
Si todavía arrancas tus proyectos con python -m venv y un requirements.txt escrito a mano, este es el cambio con más retorno de toda la lista.
Interfaces sin montar un frontend
Textual
Olvídate de levantar otro dashboard en Flask solo para revisar logs o gestionar tareas en segundo plano. A veces la interfaz es la propia terminal, y una sorprendentemente buena.
from textual.app import App, ComposeResult
from textual.widgets import Header, Footer, DataTable
class Usuarios(App):
def compose(self) -> ComposeResult:
yield Header()
tabla = DataTable()
tabla.add_columns("ID", "Nombre", "Estado")
tabla.add_rows([
("1", "Alicia", "Conectado"),
("2", "Bruno", "Desconectado"),
])
yield tabla
yield Footer()
Usuarios().run()
He usado interfaces de terminal para dashboards de despliegue, monitorización de ETL, exploradores de bases de datos y tareas de mantenimiento de larga duración. Un frontend nuevo para cada cosa cansa. Una app en Textual arranca al instante, funciona por SSH y, después de un par de ellas, se vuelve algo natural. Eso sí, no está pensada para producto de cara al cliente: para herramientas internas prefiero mantener una app en Textual antes que otro frontend en React.
Rich
Textual está construida encima de Rich, y Rich merece su propio hueco: formatea salidas de terminal con tablas, barras de progreso, resaltado de sintaxis y tracebacks legibles, sin que tengas que tocar un solo código ANSI a mano.
from rich.console import Console
from rich.table import Table
console = Console()
tabla = Table(title="Usuarios activos")
tabla.add_column("ID")
tabla.add_column("Nombre")
tabla.add_row("1", "Alicia")
console.print(tabla)
Es la típica librería que instalas para un script rápido y acabas usando en todas partes: CLIs, logs de depuración, mensajes de progreso en scripts largos.
Datos sin perder el día
sqlite-utils
SQLite ya es una de las armas secretas de Python. sqlite-utils hace que se sienta como algo de 2026 y no de 2006.
from sqlite_utils import Database
db = Database("inventario.db")
db["productos"].insert({
"sku": "A-104",
"precio": 19.99,
"stock": 42
})
for fila in db["productos"].rows:
print(fila)
Importar CSVs, generar índices, sacar informes rápidos, inspeccionar datos: casi todo se reduce a una o dos líneas. La uso constantemente en prototipos porque la evolución del esquema deja de doler. Tarde o temprano crecerás y necesitarás otra cosa, pero la mayoría de proyectos nunca llegan a ese punto.
DuckDB
Suena a librería de ingeniería de datos. Ya no lo es solo eso: se ha convertido en la navaja suiza de cualquiera que toque ficheros estructurados.
import duckdb
resultado = duckdb.sql("""
SELECT *
FROM 'logs/*.parquet'
WHERE tiempo_respuesta > 500
LIMIT 20
""").df()
print(resultado)
¿Necesitas inspeccionar cinco gigas de logs? Sin base de datos, sin importación previa, sin preprocesado: solo SQL directo sobre el fichero. Muchos scripts de «procesamiento de datos» son, en realidad, problemas de SQL disfrazados. DuckDB te deja admitirlo sin vergüenza.
Polars
Si tu cuello de botella no es SQL sino manipular dataframes en memoria, Polars se ha ganado el sitio que antes ocupaba pandas en solitario. Está escrita en Rust, libera el GIL durante el cálculo y reparte el trabajo entre todos los núcleos disponibles. Eso se traduce en mejoras de entre 5 y 30 veces en agregaciones, joins y expresiones sobre datasets grandes, con bastante menos memoria que pandas.
import polars as pl
df = pl.read_csv("ventas.csv")
resumen = (
df.lazy()
.filter(pl.col("importe") > 100)
.group_by("cliente")
.agg(pl.col("importe").sum())
.collect()
)
print(resumen)
No hace falta elegir bando: en 2026 es habitual ver DuckDB para la ingesta inicial, Polars para la capa intermedia de transformación, y pandas en el punto donde todo eso conecta con scikit-learn o una librería de gráficos. Las tres hablan Arrow de forma nativa, así que combinarlas no duele tanto como parece.
Red y APIs que no se caen a la primera
httpx
requests sigue funcionando de maravilla si tu código es síncrono y no necesitas nada más. Pero httpx ofrece lo mismo con soporte async, HTTP/2 y una API prácticamente calcada, así que migrar no supone reescribir nada.
import httpx
async def obtener_usuario(id_usuario: int):
async with httpx.AsyncClient(http2=True) as client:
r = await client.get(f"https://api.ejemplo.com/usuarios/{id_usuario}")
return r.json()
Si vas a arrancar un proyecto desde cero hoy, empezar directamente con httpx te ahorra una migración más adelante, y el coste de entrada es prácticamente nulo.
LiteLLM
Dar soporte a varios proveedores de modelos de lenguaje a mano se vuelve repetitivo muy rápido.
from litellm import completion
respuesta = completion(
model="gpt-4o-mini",
messages=[
{"role": "user", "content": "Resume este documento."}
]
)
print(respuesta.choices[0].message.content)
He usado LiteLLM para alternar entre OpenAI, Anthropic, Gemini y modelos locales durante fases de evaluación, sin reescribir código cada vez que cambiaba de proveedor. El precio a pagar es la propia capa de abstracción: en cuanto necesitas una función específica de un proveedor concreto, esta librería deja de ser suficiente y hay que esquivarla para esa parte del proyecto.
Tenacity
Las redes fallan, las APIs limitan peticiones, las bases de datos se reinician. Los reintentos suenan sencillos hasta que intentas hacerlos bien de verdad.
from tenacity import retry, wait_exponential
@retry(wait=wait_exponential(multiplier=1, max=20))
def obtener_datos():
...
El primer decorador de reintento parece casi innecesario. La vigésima vez que recupera solo un fallo transitorio, dejas de pensar en ello. Pero ojo: reintentar a ciegas errores de validación o peticiones mal formadas solo amplifica el fallo. Tenacity te da las herramientas; el criterio de cuándo no reintentar sigue siendo cosa tuya.
Estructura y configuración que no se rompe en producción
msgspec
El parseo de JSON no suele ser el cuello de botella de una aplicación, hasta que de repente lo es.
import msgspec
class Pedido(msgspec.Struct):
id: int
cliente: str
total: float
payload = b'{"id":5,"cliente":"Alicia","total":92.4}'
pedido = msgspec.json.decode(payload, type=Pedido)
print(pedido.total)
La velocidad se nota, pero lo mejor es el tipado estricto: dejas de pasarte diccionarios cuya forma «todo el mundo conoce más o menos». Frente a frameworks de validación más pesados, msgspec se queda con lo esencial. El ecosistema alrededor es más pequeño, pero la librería en sí está muy pulida.
Pydantic Settings
Los ficheros de configuración crecen sin que nadie se dé cuenta: variables de entorno, secretos, feature flags, URLs de base de datos, claves de API. Tarde o temprano algo se rompe porque una variable no estaba definida.
from pydantic_settings import BaseSettings
class Settings(BaseSettings):
database_url: str
api_key: str
debug: bool = False
settings = Settings()
print(settings.database_url)
En vez de descubrir el error de configuración después del despliegue, la aplicación se niega a arrancar. Casi siempre es preferible. El precio es una dependencia más, una que en cualquier sistema en producción merece la pena pagar.
Observabilidad y mantenimiento sin dolor
Loguru
El logging suele empezar sencillo. Seis meses después tienes handlers duplicados, configuración ilegible y ficheros de log de los que nadie se fía.
from loguru import logger
logger.add(
"servidor.log",
rotation="200 MB",
retention="10 days"
)
logger.info("Servidor iniciado.")
logger.error("Timeout en la base de datos.")
La configuración es donde la mayoría de sistemas de logging se vuelven un incordio. Loguru se la salta casi entera. El límite está en organizaciones que ya han estandarizado el módulo logging de la librería estándar: meter otro sistema de logging ahí puede no merecer la pena. Para proyectos en solitario, cuesta volver atrás una vez lo pruebas.
DiskCache
Cachear no siempre exige levantar Redis. A veces solo necesitas algo que sobreviva a un reinicio del proceso.
from diskcache import Cache
cache = Cache("cache")
cache["informe"] = {
"usuarios": 15234,
"ventas": 981
}
print(cache["informe"])
DiskCache gestiona persistencia, expiración y acceso concurrente sin que tengas que pensar en ello. Lo he usado para cachear respuestas de API, resultados de inferencia de modelos, informes caros de generar y metadatos temporales. Muchos desarrolladores saltan directamente a Redis, muchas veces porque se olvidan de que el almacenamiento local sigue ahí.
Watchfiles
Consultar un directorio cada pocos segundos para ver si ha cambiado algo es de esas cosas que todo desarrollador acaba escribiendo por su cuenta al menos una vez. No hace falta.
from watchfiles import watch
for cambios in watch("entrada"):
for cambio in cambios:
print(cambio)
Lo he usado en jobs de ETL automáticos, pipelines de procesado de imágenes, scripts de despliegue local e indexado de documentos. Sueltas un fichero en una carpeta y el pipeline arranca solo, sin cron, sin bucles infinitos comprobando timestamps. Un aviso: los eventos del sistema de ficheros se comportan de forma distinta según el sistema operativo, así que si tu software corre en varios, pruébalo en todos antes de confiar en él a ciegas.
La lista completa, para guardar
- uv gestión de paquetes, entornos y versiones de Python en un solo binario.
- Textual interfaces de terminal completas, sin frontend web.
- Rich formateo de terminal, tablas, progreso y tracebacks legibles.
- sqlite-utils SQLite fácil de manejar para prototipos e informes rápidos.
- DuckDB SQL directo sobre CSV, Parquet o JSON, sin base de datos previa.
- Polars dataframes en Rust, mucho más rápidos que pandas en datasets grandes.
- httpx cliente HTTP síncrono y asíncrono con soporte HTTP/2.
- LiteLLM una sola API para OpenAI, Anthropic, Gemini y modelos locales.
- Tenacity reintentos con criterio ante fallos transitorios.
- msgspec serialización JSON rápida con tipado estricto.
- Pydantic Settings configuración validada desde variables de entorno.
- Loguru logging sin configuración eterna.
- DiskCache caché persistente en disco, sin montar Redis.
- Watchfiles reacciona a cambios de ficheros sin polling manual.
Ninguna de estas librerías te va a hacer mejor programador por sí sola. Pero cada una elimina una categoría entera de trabajo que, de otra forma, tendrías que escribir, mantener y depurar tú mismo. Cuantas menos personas hay en tu equipo, más se nota.
Documentación oficial de cada librería
- uv: docs.astral.sh/uv
- Textual: textual.textualize.io
- Rich: github.com/Textualize/rich
- sqlite-utils: sqlite-utils.datasette.io
- DuckDB: duckdb.org/docs
- Polars: docs.pola.rs
- httpx: python-httpx.org
- LiteLLM: docs.litellm.ai
- Tenacity: tenacity.readthedocs.io
- msgspec: jcristharif.com/msgspec
- Pydantic Settings: docs.pydantic.dev
- Loguru: loguru.readthedocs.io
- DiskCache: grantjenks.com/docs/diskcache
- Watchfiles: watchfiles.helpmanual.io
Imagen: Pexels / Stanislav Kondratiev